package com.ldn.database.dao.impl;

import com.ldn.common.basic.utils.system.DateUtils;
import com.ldn.database.dao.entities.BasicEntities;
import com.ldn.database.dao.mapper.BasicMapper;
import com.ldn.database.dao.service.BasicService;
import com.ldn.database.dao.entities.Page;
import com.mybatisflex.core.query.QueryWrapper;
import com.mybatisflex.spring.service.impl.ServiceImpl;

import java.io.Serializable;
import java.util.List;

/**
 * @author 李大牛家的牛 (scafel@163.com)
 * @product serverless
 * @className BasicImpl
 * @createDate 2025/1/14 - 11:02
 * @description ToDo...
 **/
@SuppressWarnings("unused")
public class BasicImpl<M extends BasicMapper<T>, T extends BasicEntities> extends ServiceImpl<M, T> implements BasicService<T> {
    /**
     * 保存
     * @param entity 实体对象
     * @return 是否保存成功
     */
    public boolean saveEntity(T entity) {
        return super.save(setAddField(entity));
    }
    /**
     * 批量保存
     * @param entities 实体对象列表
     * @return 是否保存成功
     */
    public boolean saveBatchEntity(List<T> entities) {
        entities.forEach(this::setAddField);
        return super.saveBatch(entities);
    }
    /**
     * 批量更新
     * @param entities 实体对象列表
     * @return 是否更新成功
     */
    public boolean updateBatchEntity(List<T> entities) {
        entities.forEach(this::setBaseField);
        return super.updateBatch(entities);
    }
    /**
     * 更新
     * @param entity 实体对象
     * @return 是否更新成功
     */
    public boolean updateEntity(T entity) {
        return super.updateById(setBaseField(entity));
    }
    /**
     * 删除
     * @param entity 实体对象
     * @return 是否删除成功
     */
    public boolean deleteEntity(T entity) {
        return super.updateById(setDeleteField(entity));
    }
    /**
     * 批量删除
     * @param ids 删除的id
     * @return 是否删除成功
     */
    public boolean deleteBatchEntity(List<? extends Serializable> ids) {
        return super.removeByIds(ids);
    }

    /**
     * 批量删除
     * @param entities 实体对象列表
     * @return 是否删除成功
     */
    @Override
    public boolean deleteBatchEntities(List<T> entities) {
        entities.forEach(this::setDeleteField);
        return super.updateBatch(entities);
    }

    /**
     * 设置状态
     * @param entity 实体对象
     * @return 设置状态后的实体对象
     */
    public boolean statusEntity(T entity) {
        return super.updateById(setStatusField(entity));
    }

    @Override
    public boolean statusBatchEntity(List<T> entities) {
        entities.forEach(this::setStatusField);
        return super.updateBatch(entities);
    }

    /**
     * 设置受保护
     * @param entity 实体对象
     * @return 设置受保护后的实体对象
     */
    public boolean protectEntity(T entity) {
        return super.updateById(setProtectField(entity));
    }
    /**
     * 设置热门
     * @param entity 实体对象
     * @return 设置热门后的实体对象
     */
    public boolean hotEntity(T entity) {
        return super.updateById(setHotField(entity));
    }
    /**
     * 分页获取列表
     * @param page 页码
     * @param size 页大小
     * @param query 查询条件
     * @return 分页列表
     */
    public Page<T> page(Integer page, Integer size, QueryWrapper query) {
        return covertPage(super.page(Page.of(page, size), query));
    }

    /**
     * 分页获取列表
     * @param page 页码
     * @param size 页大小
     * @param validStatus 是否校验status=1的数据
     * @return 分页列表
     */
    public Page<T> pageEntity(Integer page, Integer size, boolean validStatus) {
        QueryWrapper queryWrapper = QueryWrapper.create();
        queryWrapper.orderBy("id", false);
        if (validStatus) {
            queryWrapper.eq("status", '1');
        }
        return this.page(page, size, queryWrapper);
    }
    /**
     * 获取列表
     * @param validStatus 是否校验status=1的数据
     * @return 列表
     */
    public List<T> listEntity(boolean validStatus) {
        if (validStatus){
            return super.list(QueryWrapper.create().eq("status", 1));
        }
        return super.list();
    }
    /**
     * 获取列表
     * @param page 页码
     * @return 列表
     */
    public List<T> listEntity(Integer page) {
        return super.page(Page.of(page, PAGE_SIZE)).getRecords();
    }
    /**
     * 根据状态获取列表
     * @param page 页码
     * @return 列表
     */
    public List<T> listStatusEntity(Integer page) {
        return super.page(Page.of(page, PAGE_SIZE), QueryWrapper.create().eq("status", 1)).getRecords();
    }
    /**
     * 设置添加基础字段
     * <p>
     *     添加了创建时间、状态
     * </p>
     * @param entity 实体对象
     * @return 添加了基础信息的实体对象
     * @param <E> 实体对象类型
     */
    protected <E extends BasicEntities>E setAddField(E entity) {
        entity.setCtime(DateUtils.getCurrentS());
        if (entity.getStatus() == 1){
            entity.setStatus(1);
        } else {
            entity.setStatus(0);
        }
        entity = setBaseField(entity);
        return entity;
    }
    /**
     * 设置热门基础字段
     * <p>
     *     修改了热门字段
     * </p>
     * @param entity 实体对象
     * @return 修改了热门基础信息的实体对象
     * @param <E> 实体对象类型
     */
    protected <E extends BasicEntities>E setHotField(E entity) {
        if (entity.getHot() == 1) {
            entity.setHot(0);
        } else {
            entity.setHot(1);
        }
        entity = setBaseField(entity);
        return entity;
    }

    /**
     * 设置受保护的基础字段
     * @param entity 实体对象
     * @return 设置受保护的基础信息的实体对象
     * @param <E> 实体对象类型
     */
    protected <E extends BasicEntities>E setProtectField(E entity) {
        if (entity.getProtect() == 1) {
            entity.setProtect(0);
        } else {
            entity.setProtect(1);
        }
        entity = setBaseField(entity);
        return entity;
    }
    /**
     * 设置状态基础字段
     * <p>
     *     修改了状态字段
     * </p>
     * @param entity 实体对象
     * @return 修改了状态基础信息的实体对象
     * @param <E> 实体对象类型
     */
    protected <E extends BasicEntities>E setStatusField(E entity) {
        if (entity.getStatus() == 1) {
            entity.setStatus(0);
        } else {
            entity.setStatus(1);
        }
        entity = setBaseField(entity);
        return entity;
    }

    /**
     * 设置伪删除基础字段
     * <p>
     *     添加了删除时间、伪删除标记
     * </p>
     * @param entity 实体对象
     * @return 添加了伪删除基础信息的实体对象
     * @param <E> 实体对象类型
     */
    protected <E extends BasicEntities>E setDeleteField(E entity) {
        entity.setDeleted(1);
        entity.setDtime(DateUtils.getCurrentS());
        entity = setBaseField(entity);
        return entity;
    }

    /**
     * 设置基础字段
     * <p>
     *     添加了更新时间、更新IP、更新操作系统
     * </p>
     * @param entity 实体对象
     * @return 添加了基础信息的实体对象
     * @param <E>  实体对象类型
     */
    protected <E extends BasicEntities>E setBaseField(E entity) {
        entity.setUtime(DateUtils.getCurrentS());
//        entity.setUos(NetWorkUtils.getOsName());
//        entity.setUip(NetWorkUtils.getIpAddr());
        return entity;
    }

    /**
     * 将mybatis-flex的分页对象转换为自定义的分页对象
     * @param p 将mybatis-flex的分页对象
     * @return 自定义的分页对象
     */
    protected Page<T> covertPage(com.mybatisflex.core.paginate.Page<T> p) {
        Page<T> page = new Page<>();
        page.setPageNumber(p.getPageNumber());
        page.setPageSize(p.getPageSize());
        page.setTotalPage(p.getTotalPage());
        page.setTotalRow(p.getTotalRow());
        page.setRecords(p.getRecords());
        return page;
    }

}
